N = int(input())

dp = [[0] * 10 for _ in range(N + 1)]

for i in range(1, 10):
    dp[1][i] = 1

for i in range(2, N + 1):
    for j in range(10):
        if j == 0:
            dp[i][j] = dp[i - 1][1]
        elif 1 <= j <= 8:
            dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j + 1]
        else:
            dp[i][j] = dp[i - 1][8]


print(sum(dp[N]) % 1000000000)

import sys

def recursion(paper, row_start, col_start, step):
    # 종이가 같은지 검사
    result = check_paper_same(paper, row_start, col_start, step)

    # 같지 않다면 9분할한뒤 각각을 재귀적으로 검사
    if result == 2:
        for i in range(3):
            for j in range(3):
                row = row_start + (i * step // 3)
                col = col_start + (j * step // 3)
                recursion(paper, row, col, step // 3)
    else:
        # 종이의 칸이 다 같은 경우
        answer[result] += 1



def check_paper_same(paper, row_start, col_start, step):
    base = paper[row_start][col_start]
    for i in range(row_start, row_start + step):
        for j in range(col_start, col_start + step):
            if paper[i][j] != base:
                return 2
    return base


inp = sys.stdin.readline

n = int(inp())

paper = []

# 각각 -1, 0, 1로만 이루어진 종이의 개수 저장 딕셔너리
global answer
answer = {-1: 0, 0: 0, 1: 0}

for i in range(n):
    paper.append(list(map(int, inp().split())))

recursion(paper, 0, 0, n)

print('\n'.join(str(value) for value in answer.values()))

import sys

input = sys.stdin.readline

N = int(input())
dp = [[[0 for _ in range(1 << 10)] for _ in range(10)] for _ in range(N)]
mod = 1000000000
res = 0

for k in range(1, 10):
    dp[0][k][1 << k] = 1

for i in range(1, N):
    for k in range(10):
        for bit in range(1024):
            if k - 1 >= 0:
                dp[i][k][bit | (1 << k)] += dp[i - 1][k - 1][bit]
            if k + 1 <= 9:
                dp[i][k][bit | (1 << k)] += dp[i - 1][k + 1][bit]
            dp[i][k][bit | (1 << k)] %= mod

for k in range(10):
    res += dp[N - 1][k][1023]
    res %= mod

print(res)